home *** CD-ROM | disk | FTP | other *** search
/ Turnbull China Bikeride / Turnbull China Bikeride - Disc 2.iso / STUTTGART / UTIL / MEMORY / OLD / MEM208SRC / FSLib / c / _Func < prev    next >
Text File  |  1993-08-22  |  14KB  |  505 lines
  1. /* Original code (c) Acorn Computers Ltd, 1992-3 */
  2.  
  3. /* $Id: c._Func 3.1 93/03/09 23:14:56 brian Exp $ */
  4. #include "FS.h"
  5.  
  6. /* #define DEBUG */
  7.  
  8. static FileEntry *csd = NULL, *psd = NULL, *lib = NULL;
  9.  
  10. void fs_terminate
  11. ( void )
  12. { FileEntry_Close( csd );
  13.   FileEntry_Close( psd );
  14.   FileEntry_Close( lib );
  15.   csd=NULL;
  16.   psd=NULL;
  17.   lib=NULL;
  18. }
  19.  
  20. _kernel_oserror *reportusage( char *drivespec )
  21. { struct freespace b;
  22.   FileEntry *fe;
  23.   _kernel_oserror *err;
  24.   char buf[256];
  25.   if (drivespec[0] && drivespec[0]!=':')
  26.   { strcpy(buf,":");
  27.     strcat(buf,drivespec);
  28.     drivespec=buf;
  29.   }
  30.   fe=NULL;
  31.   err=FileEntry_Open(NULL,drivespec,OPENIN,&fe);
  32.   if (err)
  33.     return err;
  34.   err=FileEntry_FreeSpace(fe,&b);
  35.   FileEntry_Close(fe);
  36.   if (err)
  37.     return err;
  38.   printf( "Bytes free &%08x = %9d\n\rBytes used &%08x = %9d\n\r",
  39.                 b.free, b.free, b.size-b.free, b.size-b.free );
  40.   return NULL;
  41. }
  42.  
  43. #ifndef RISCOS3ONLY
  44. static void header
  45. ( FileEntry *fse )
  46. { char *disc = FileEntry_DiscName( csd );
  47.   printf( "%-20s", FileEntry_Name( fse ));
  48.   if (disc) printf( "Disc %-15s", disc );
  49.   printf( "Option %-13s", "" );
  50.   printf( "\n\r" );
  51.   printf( "Dir %-16s", FileEntry_Name( csd ));
  52.   printf( "Lib %-16s", FileEntry_Name( lib ));
  53.   printf( "Prev %-15s", FileEntry_Name( psd ));
  54.   printf( "\n\r\n" );
  55. }
  56.  
  57. static int maxname
  58. ( FileEntry *fse )
  59. {
  60.   int i;
  61.   FileDesc d;
  62.   char *name;
  63.   int m=0;
  64.   for ( i = 0;!FileEntry_DirScan( fse, i, &d, &name );++i )
  65.     if ( strlen(name)>m )
  66.       m = strlen(name);
  67.   return m;
  68. }
  69.  
  70. static void catdir
  71. ( FileEntry *fse )
  72. {
  73.   int i;
  74.   int width = readwidth();
  75.   int k = 0;
  76.   int l = maxname( fse )+1;
  77.   FileDesc d;
  78.   char *name;
  79.   header( fse );
  80.   for ( i = 0;!FileEntry_DirScan( fse, i, &d, &name );++i )
  81.   { if ( k > width-l )
  82.     { printf( "\r\n" );
  83.       k = 0;
  84.     }
  85.     printf( "%-*s", l+1, name );
  86.     k += l+1;
  87.   }
  88.   printf( "\r\n" );
  89. }
  90.  
  91. static char *accessstring
  92. ( int a )
  93. { static char buf[5];
  94.   char *p=buf;
  95.   if ( a&Attr_L )
  96.     *p++='L';
  97.   if ( a&Attr_R )
  98.     *p++='R';
  99.   if ( a&Attr_W )
  100.     *p++='W';
  101. /*  if ( a&Attr_D )
  102.     *p++='D'; */
  103.   *p++=0;
  104.   return buf;
  105. }
  106.  
  107. static char *infoobject
  108. ( FileDesc d )
  109. { int date[2];
  110.   _kernel_swi_regs r;
  111.   int l;
  112. #define MAXCOL 70
  113.   static char buf[MAXCOL];
  114.   date[0]=d.info.date_type.part_2;
  115.   date[1]=d.info.date_type.part_1;
  116. #define TYPECOL 4
  117. #define DATECOL 14
  118. #define MAXDATELEN 30
  119.   sprintf( buf, "%-3s ", accessstring( d.attr ) );
  120.   r.r[0]=(int)&date;
  121.   r.r[1]=(int)buf+DATECOL;
  122.   r.r[2]=MAXDATELEN;
  123.   if ( 2==d.type )
  124.   { strcpy( buf+TYPECOL, "Directory " );
  125.     _kernel_swi( XOS_Bit+OS_ConvertStandardDateAndTime, &r, &r );
  126.   }
  127.   else if ( (d.info.date_type.part_1>>20)==-1 )
  128.   { int t = d.info.date_type.part_1>>8&0xfff;
  129.     char *n;
  130.     sprintf( buf+TYPECOL, "File$Type_%03x", t );
  131.     n=getenv( buf+TYPECOL );
  132.     if (n)
  133.       sprintf( buf+TYPECOL, "%-8.8s  ", n );
  134.     else
  135.       sprintf( buf+TYPECOL, "&%03x      ", t );
  136.     _kernel_swi( XOS_Bit+OS_ConvertStandardDateAndTime, &r, &r );
  137.   }
  138.   else
  139.   { _kernel_swi( XOS_Bit+OS_ConvertStandardDateAndTime, &r, &r );
  140.     l = DATECOL + strlen(buf+DATECOL) - TYPECOL - 17;
  141.     sprintf( buf+TYPECOL, "%*s%08x %08x", l, "", d.info.date_type.part_1, d.info.date_type.part_2 );
  142.   }
  143.   strcat( buf, " " );
  144.   l = strlen( buf );
  145.   r.r[0] = d.length;
  146.   r.r[1] = (int)buf+l;
  147.   r.r[2] = MAXCOL-l;
  148.   _kernel_swi( OS_ConvertFixedFileSize, &r, &r );
  149.   return buf;
  150. }
  151.  
  152. static void examinedir
  153. ( FileEntry *fse )
  154. {
  155.   int i;
  156.   FileDesc d;
  157.   char *name;
  158.   int l = maxname( fse )+1;
  159.   header( fse );
  160.   for ( i = 0; !FileEntry_DirScan( fse, i, &d, &name ); ++i )
  161.     printf( "%-*s %s\n", l, name, infoobject( d ) );
  162. }
  163. #endif
  164.  
  165. void normalise
  166. ( FileEntry **dir, char **name )
  167. { if ( !*dir )
  168.     *dir = csd;
  169.   if ( *name )
  170.   { switch ( (*name)[0] )
  171.     { default:
  172.         return;
  173.       case '@':
  174.         *dir = csd;
  175.         break;
  176.       case '\\':
  177.         *dir = psd;
  178.         break;
  179.       case '%':
  180.         *dir = lib;
  181.         break;
  182.     }
  183.     switch ( (*name)[1] )
  184.     { case '.':
  185.         *name += 2;
  186.         break;
  187.       case 0:
  188.         *name = NULL;
  189.         break;
  190.       default:
  191.         *name = NULL;
  192.         break;
  193.     }
  194.   }
  195. }
  196.  
  197. _kernel_oserror *fsentry_func
  198. ( FSEntry_Func_Parameter *parm )
  199. {
  200.   _kernel_oserror *err = NULL;
  201.   FileEntry *fse=NULL;
  202. #ifdef DEBUG
  203.   printf( "Func( %d )%s\n", parm->reason, parm->first_parameter.name_1?parm->first_parameter.name_1:"NULL" );
  204. #endif
  205.   special_field = parm->special_field_1;
  206.   switch ( parm->reason )
  207.   {
  208. #ifndef RISCOS3ONLY
  209.   case FSEntry_Func_Reason_SetCurrentDirectory:
  210.   case FSEntry_Func_Reason_SetLibraryDirectory:
  211.     { char *name = parm->first_parameter.name_1;
  212.       FileDesc d;
  213.       if ( !name || !name[0] )
  214.         err = FileEntry_Open( NULL, NULL, OPENDIR, &fse );
  215.       else
  216.         err = FileEntry_Open( csd, parm->first_parameter.name_1, OPENDIR, &fse );
  217.       if ( err )
  218.         return err;
  219.       d = FileEntry_Desc( fse );
  220.       if ( 2!=d.type )
  221.       { FileEntry_Close( fse );
  222.         return ERR(mb_FileNotFound);
  223.       }
  224.       if ( parm->reason == FSEntry_Func_Reason_SetCurrentDirectory )
  225.       { FileEntry_Close( psd );
  226.         psd = csd;
  227.         csd = fse;
  228.       }
  229.       else
  230.       { FileEntry_Close( lib );
  231.         lib = fse;
  232.       }
  233.       return NULL;
  234.     }
  235.  
  236.   case FSEntry_Func_Reason_CatalogueDirectory:
  237.   case FSEntry_Func_Reason_ExamineCurrentDirectory:
  238.   case FSEntry_Func_Reason_CatalogueLibraryDirectory:
  239.   case FSEntry_Func_Reason_ExamineLibraryDirectory:
  240.    {  FileDesc d;
  241.       err = FileEntry_Open( parm->reason==FSEntry_Func_Reason_CatalogueLibraryDirectory ||
  242.                     parm->reason==FSEntry_Func_Reason_ExamineLibraryDirectory ? lib : csd,
  243.                     parm->first_parameter.name_1, OPENDIR, &fse );
  244.       if ( err )
  245.         return err;
  246.       d = FileEntry_Desc( fse );
  247.       if ( 2!=d.type )
  248.       { FileEntry_Close( fse );
  249.         return ERR(mb_FileNotFound);
  250.       }
  251.       if ( parm->reason==FSEntry_Func_Reason_ExamineLibraryDirectory || 
  252.            parm->reason==FSEntry_Func_Reason_ExamineCurrentDirectory )
  253.         examinedir( fse );
  254.       else
  255.         catdir( fse );
  256.       FileEntry_Close( fse );
  257.       return NULL;
  258.     }
  259.  
  260.   case FSEntry_Func_Reason_ExamineObjects:
  261.       err = FileEntry_Open( csd, parm->first_parameter.name_1, OPENIN, &fse );
  262.       if ( err )
  263.         return err;
  264.       printf( "%s %s\n", FileEntry_Name( fse ), infoobject( FileEntry_Desc( fse ) ) );
  265.       FileEntry_Close( fse );
  266.       return NULL;
  267.  
  268.   case FSEntry_Func_Reason_SetFilingSystemOptions:
  269.           return NULL;
  270. #endif
  271.   case FSEntry_Func_Reason_RenameObject:
  272.           err=FileEntry_Rename( csd, parm->first_parameter.name_1,
  273.                                 csd, parm->second_parameter.name_2 );
  274.           parm->first_parameter.rename_invalid = !!err;
  275.           return err;
  276. #ifndef RISCOS3ONLY
  277.   case FSEntry_Func_Reason_AccessObjects:
  278.       { char *p=parm->second_parameter.access_string;
  279.         int a=0;
  280.         int sl=0;
  281.         for (;;)
  282.         { switch (*p++)
  283.           { case 0:   break;
  284.             case '/': sl=1; continue;
  285.             case 'L': case 'l': a|=Attr_L; continue;
  286.             case 'R': a|=sl?Attr_r:Attr_R; continue;
  287.             case 'W': a|=sl?Attr_w:Attr_W; continue;
  288.             case 'r': a|=Attr_r; continue;
  289.             case 'w': a|=Attr_w; continue;
  290.           }
  291.           break;
  292.         }
  293.         err = FileEntry_Access( csd, parm->first_parameter.name_1, a );
  294.         return err;
  295.       }
  296.  
  297.   case FSEntry_Func_Reason_BootFilingSystem:
  298.           return NULL;
  299. #endif
  300.   case FSEntry_Func_Reason_ReadNameAndBootOptionOfDisc:
  301.     { char *disc = FileEntry_DiscName( csd );
  302.       strcpy( (char * )parm->second_parameter.parameter+1, disc?disc:"" );
  303.       *(char * )parm->second_parameter.parameter = strlen( (char * )parm->second_parameter.parameter+1 );
  304.       return NULL;
  305.     }
  306. #ifndef RISCOS3ONLY
  307.   case FSEntry_Func_Reason_ReadCurrentDirectoryNameAndPrivilegeByte:
  308.     {
  309.       char *p = ( char * )parm->second_parameter.parameter;
  310.       char *name = FileEntry_Name( csd );
  311.       *p++ = 0;
  312.       *p++ = strlen( name );
  313.       strcpy( p, name );
  314.       return NULL;
  315.     }
  316.  
  317.   case FSEntry_Func_Reason_ReadLibraryDirectoryNameAndPrivilegeByte:
  318.     {
  319.       char *p = ( char * )parm->second_parameter.parameter;
  320.       char *name = FileEntry_Name( lib );
  321.       *p++ = 0;
  322.       *p++ = strlen( name );
  323.       strcpy( p, name );
  324.       return NULL;
  325.     }
  326. #endif
  327.   case FSEntry_Func_Reason_ReadDirectoryEntries:
  328.   case FSEntry_Func_Reason_ReadDirectoriesAndInformation:
  329.   case FSEntry_Func_Reason_ReadDirectoryEntriesAndInformation:
  330.     {
  331.       int xtra = parm->reason == FSEntry_Func_Reason_ReadDirectoryEntries ? 0 :
  332.                  parm->reason == FSEntry_Func_Reason_ReadDirectoriesAndInformation ? 20 :
  333.                                                                             30;
  334.       int *par = ( int * )parm;
  335.       int *p = ( int * )par[2];
  336.       int n = par[3];
  337.       int o = par[4];
  338.       int l = par[5];
  339.       int k = 0, x = 0;
  340.       FileDesc d;
  341.       char *name;
  342.       err = FileEntry_Open( csd, parm->first_parameter.name_1, OPENDIR, &fse );
  343.       if ( err )
  344.         return err;
  345.       d = FileEntry_Desc( fse );
  346.       if ( 2!=d.type )
  347.       { FileEntry_Close( fse );
  348.         return ERR(mb_FileNotFound);
  349.       }
  350. #ifdef DEBUG
  351.       printf( "at $%p+%d %d from %d:", p, l, n, o );
  352. #endif
  353.       for ( x = o; NULL==(err=FileEntry_DirScan( fse, x, &d, &name )) &&
  354.                         n>0 && l > xtra + ( k = strlen( name ) ) ; ++x )
  355.         if ( parm->reason == FSEntry_Func_Reason_ReadDirectoryEntries )
  356.         {
  357.           strcpy( (char *)p, name );
  358.           p = (int *)((int)p+k+1);
  359.           --n;
  360.           l -= k+1;
  361.         }
  362.         else
  363.         { *p++ = ( int )d.info.load_exec.load_address;
  364.           *p++ = ( int )d.info.load_exec.execute_address;
  365.           *p++ = d.length;
  366.           *p++ = d.attr;
  367.           *p++ = d.type;
  368.           if ( parm->reason == FSEntry_Func_Reason_ReadDirectoriesAndInformation )
  369.           {
  370.             strcpy( (char * )p, name );
  371.             p+= k/4+1;
  372.             --n;
  373.             l-= ( k/4+1 )*4+20;
  374.           }
  375.           else
  376.           {
  377.             *p++ = 0;
  378.             *p++ = d.info.date_type.part_2;
  379.             *( char * )p = d.info.date_type.part_1;
  380.             strcpy( (char* )p+1, name );
  381.             p+= ( k+1 )/4+1;
  382.             --n;
  383.             l-= ( (k+1 )/4+1 )*4+30;
  384.           }
  385.         }
  386.       par[3] = x-o;
  387.       par[4] = (!err || x-o)?x:-1;
  388.       FileEntry_Close( fse );
  389.       if (err && 0x100D6!=err->errnum)
  390.         return err;
  391.       return NULL;
  392.     }
  393.  
  394.   case FSEntry_Func_Reason_ShutDown:
  395.           /* ShutDown_FileEntrys(); */
  396.           return NULL;
  397.  
  398.   case FSEntry_Func_Reason_PrintStartUpBanner:
  399.           printf( "\n%s\n", ModuleName );
  400.           return NULL;
  401. #if 0
  402.   case FSEntry_Func_Reason_SetDirectoryContexts:
  403.     {
  404.       int *par = ( int * )parm;
  405.       FileEntry *oldcsd = csd, *oldlib = lib;
  406.       printf( "****SetDirectoryContexts %x %x %x\n", par[1], par[2], par[3] );
  407.       if ( par[1] )
  408.         csd = par[1]==-1?NULL:(FileEntry *)par[1];
  409.       if ( par[3] )
  410.         lib = par[3]==-1?NULL:(FileEntry *)par[3];
  411.       par[1] = oldcsd?(int)oldcsd:-1;
  412.       par[2] = -1;
  413.       par[3] = oldlib?(int)oldlib:-1;
  414.       return NULL;
  415.     }
  416. #endif
  417.   case FSEntry_Func_Reason_OutputFullInformationOnObjects:
  418.     {
  419.       err = FileEntry_Open( csd, parm->first_parameter.name_1, OPENIN, &fse );
  420.       if ( err )
  421.         return err;
  422.       FileEntry_FileInfoObject( fse );
  423.       FileEntry_Close( fse );
  424.       return NULL;
  425.     }
  426.   case FSEntry_Func_Reason_CanonicaliseSpecialFieldAndDiscName:
  427.     { struct canonparms
  428.       { int reason;
  429.         char *special_field, *discname;
  430.         char *sfbuf, *discbuf;
  431.         int sflen, disclen;
  432.       } *p = (struct canonparms *)parm;
  433.       char buf[256];
  434.       char *sf,*disc;
  435.       special_field = p->special_field;
  436. #ifdef DEBUG
  437.       printf("%d %x %x %x %x %x %x\n",*p);
  438. #endif
  439.       if (p->discname)
  440.       { strcpy(buf,":");
  441.         strcat(buf,p->discname);
  442.         err = FileEntry_Open( csd, buf, OPENIN, &fse );
  443.       }
  444.       else
  445.         err = FileEntry_Open( csd, "$", OPENIN, &fse );
  446.       if (err)
  447.         return err;
  448.       sf = FileEntry_SpecialField(fse);
  449.       disc = FileEntry_DiscName(fse);
  450. #ifdef DEBUG
  451.       printf("sf=%s,disc=%s\n",sf?sf:"NULL",disc?disc:"NULL");
  452. #endif
  453.       if (sf)
  454.       { int l=strlen(sf)+1;
  455.         p->special_field=p->sfbuf;
  456.         if (p->sfbuf)
  457.         { memcpy(p->sfbuf,sf,l<p->sflen?l:p->sflen);
  458.           p->sfbuf = (char *)(l<p->sflen?0:p->sflen-l);
  459.         }
  460.         else
  461.           p->sfbuf = (char *)(l-1);
  462.       }
  463.       else
  464.       { p->special_field = NULL;
  465.         p->sfbuf = (char *)0;
  466.       }
  467.       if (disc)
  468.       { int l=strlen(disc)+1;
  469.         p->discname=p->discbuf;
  470.         if (p->discbuf)
  471.         { memcpy(p->discbuf,disc,l<p->disclen?l:p->disclen);
  472.           p->discbuf = (char *)(l<p->disclen?0:p->disclen-l);
  473.         }
  474.         else
  475.           p->discbuf = (char *)(l-1);
  476.       }
  477.       else
  478.       { p->discname = NULL;
  479.         p->discbuf = (char *)0;
  480.       }
  481.       FileEntry_Close(fse);
  482. #ifdef DEBUG
  483.       printf("==>%d %x %x %x %x %x %x\n",*p);
  484. #endif
  485.       return err;
  486.     }
  487.   case FSEntry_Func_Reason_ReadFreeSpace:
  488.     { err = FileEntry_Open( csd, parm->first_parameter.name_1, OPENIN, &fse );
  489.       if (err)
  490.         return err;
  491.       err = FileEntry_FreeSpace( fse, (struct freespace *)parm );
  492.       FileEntry_Close(fse);
  493.       return err;
  494.     }
  495.   case FSEntry_Func_Reason_ReadBootOption:
  496.     parm->second_parameter.parameter = 0;
  497.     return NULL;
  498.   case FSEntry_Func_Reason_ResolveWildcard:
  499.     parm->read_offset=-1;
  500.     return NULL;
  501.   default:
  502.           return ERR(mb_BadParameters);
  503.   }
  504. }
  505.